home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / jovept2.arc / MISC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-05-30  |  9.1 KB  |  574 lines
  1. /* misc.c */
  2.  
  3. /* JOVE/MSDOS. K. Mitchum 1/85 */
  4. /* Modifications for personal use only. */
  5. /* original code J. Payne LSRHS 5/83 */
  6. /* Ken Mitchum */
  7. /* University of Pittsburgh */
  8. /* Decision Systems Laboratory */
  9. /*
  10.    Jonathan Payne at Lincoln-Sudbury Regional High School 5-25-83
  11.   
  12.    jove_misc.c
  13.  
  14.    Miscellanious commands... */
  15.  
  16. #include "jove.h"
  17.  
  18. #ifdef UNIX
  19. #include <signal.h>
  20. #include <ctype.h>
  21. #else
  22. #include "signal.h"
  23. #endif
  24.  
  25. extern int Crashing;
  26. extern int    Interactive;
  27. extern BUFFER *world;    /* main.c */
  28. extern jmp_buf mainjmp;    /* main.c */
  29.  
  30.  
  31. #define ASKSIZE    132
  32.  
  33.  
  34.  
  35. static int RecDepth;
  36.  
  37.  
  38. ChrToOct()
  39. {
  40.     int    c = getch();
  41.  
  42.     ins_str(sprint("\\%03o", c));
  43. }
  44.  
  45. char *
  46. StrIndex(dir, buf, charpos, what)
  47. char    *buf,
  48.     what;
  49. {
  50.     char    *cp = &buf[charpos],
  51.         c;
  52.  
  53.     if (dir > 0) {
  54.         while (c = *cp++)
  55.             if (c == what)
  56.                 return (cp - 1);
  57.     } else {
  58.         while (cp >= buf && (c = *cp--))
  59.             if (c == what)
  60.                 return (cp + 1);
  61.     }
  62.     return 0;
  63. }
  64.  
  65. StrLength()
  66. {
  67.     static char    inquotes[] = "Where are the quotes?";
  68.     char    *first = StrIndex(-1, linebuf, curchar, '"');
  69.     char    *last = StrIndex(1, linebuf, curchar, '"');
  70.     char    c;
  71.     int    numchars = 0;
  72.  
  73.     if (first == 0 || last == 0)
  74.         complain(inquotes);
  75.     first++;
  76.     while (first < last) {
  77.         c = *first++;
  78.         if (c == '\\') {
  79.             int    num;
  80.  
  81.             if (*first < '0' || *first > '9')
  82.                 ++first;
  83.             else {
  84.                 num = 3;
  85.                 while (num-- && (c = *first++) >= '0' &&
  86.                         c <= '9' && first < last)
  87.                     ;
  88.             }
  89.         }
  90.         numchars++;
  91.     }
  92.     s_mess("%d characters", numchars);
  93. }
  94.  
  95. SplitWind()
  96. {
  97.     curwind = div_wind(curwind);
  98. }
  99.  
  100. LINE *
  101. lastline(lp)
  102. register LINE    *lp;
  103. {
  104.     while (lp->l_next)
  105.         lp = lp->l_next;
  106.     return lp;
  107. }
  108.  
  109. /* Transpos cur_char with cur_char - 1 */
  110.  
  111. TransChar()
  112. {
  113.     char    c;
  114.  
  115.     if (curchar == 0)
  116.         complain((char *) 0);    /* BEEP */
  117.     c = linebuf[curchar - 1];
  118.     exp = 1;
  119.     DelPChar();
  120.     if (eolp()) {
  121.         BackChar();
  122.         Insertc(c);
  123.         ForChar();
  124.     } else {
  125.         ForChar();
  126.         Insertc(c);
  127.         BackChar();
  128.     }
  129. }
  130.  
  131. SetLine(line)
  132. register LINE    *line;
  133. {
  134.     DotTo(line, 0);
  135. }
  136.  
  137. UpScroll()
  138. {
  139.     SetTop(curwind, next_line(curwind->w_top, exp));
  140.     if (in_window(curwind, curline) == -1)
  141.         SetLine(next_line(curwind->w_top, HALF(curwind)));
  142. }
  143.  
  144. DownScroll()
  145. {
  146.     SetTop(curwind, prev_line(curwind->w_top, exp));
  147.     if (in_window(curwind, curline) == -1)
  148.         SetLine(next_line(curwind->w_top, HALF(curwind)));
  149. }
  150.  
  151. Leave()
  152. {
  153.     BUFFER    *bp;
  154.  
  155.     if (RecDepth == 0)
  156.         for (bp = world; bp; bp = bp->b_next)
  157.             if ((bp->b_zero) && IsModified(bp) &&
  158.                     (bp->b_type != SCRATCHBUF)) {
  159.                 confirm("Modified buffers exist.  Leave anyway? ");
  160.                 break;
  161.             }
  162.     longjmp(mainjmp, QUIT);
  163. }
  164.  
  165. KillEOL()
  166. {
  167.     LINE    *line2;
  168.     int    char2;
  169.  
  170.     if (exp_p) {
  171.         line2 = next_line(curline, exp);
  172.         if (line2 == curline)
  173.             char2 = length(curline);
  174.         else
  175.             char2 = 0;
  176.     } else if (linebuf[curchar] == '\0') {
  177.         line2 = next_line(curline, 1);
  178.         if (line2 == curline)
  179.             char2 = length(curline);
  180.         else
  181.             char2 = 0;
  182.     } else {
  183.         line2 = curline;
  184.         char2 = length(curline);
  185.     }
  186.     reg_kill(curline, curchar, line2, char2, 0);
  187. }
  188.  
  189. CtlxPrefix()
  190. {
  191.     FUNCT *fp;
  192.     int    c,
  193.         invokingchar = LastKeyStruck;
  194.  
  195.     c = (*Gtchar)();
  196.  
  197.     if (c == CTL(G)) {
  198.         PrefAbort("Prefix-2");
  199.         return;
  200.     }
  201.     fp = pref2map[c];
  202.     if (fp == 0)
  203.         Unknown(invokingchar, c);
  204.     ExecFunc(fp, 0);
  205. }
  206.  
  207. Yank()
  208. {
  209.     LINE    *line,
  210.         *lp;
  211.     BUFLOC    *dot;
  212.  
  213.     if (killbuf[killptr] == 0)
  214.         complain("Nothing to yank!");
  215.     lsave();
  216.     this_cmd = YANKCMD;
  217.     line = killbuf[killptr];
  218.     lp = lastline(line);
  219.     dot = DoYank(line, 0, lp, length(lp), curline, curchar, curbuf);
  220.     SetMark();
  221.     SetDot(dot);
  222. }
  223.  
  224. static    NumArg = 1;
  225.  
  226. GetFour(Input)
  227. int    (*Input)();
  228. {
  229.     register int    c;
  230.  
  231.     do {
  232.         NumArg *= 4;
  233.     } while ((c = (*Input)()) == CTL(U));
  234.     return c;
  235. }
  236.  
  237. GetArg(Input)
  238. int    (*Input)();
  239. {
  240.     register int    c,
  241.             i = 0;
  242.  
  243.     if (!isdigit(c = (*Input)()))
  244.         return (c | 0200);
  245.  
  246.     do
  247.         i = i * 10 + (c - '0');
  248.     while ((c = getch()) >= '0' && c <= '9');
  249.     NumArg = i;
  250.     return c;
  251. }
  252.  
  253. char *
  254. jumpup(cp)
  255. char    *cp;
  256. {
  257.     while (*cp && !isword(*cp))
  258.         cp++;
  259.     while (*cp && isword(*cp))
  260.         cp++;
  261.     return cp;
  262. }
  263.  
  264. char *
  265. backup(string, cp)
  266. char    *string, *cp;
  267. {
  268.     while (cp > string && !isword(*(cp - 1)))
  269.         cp--;
  270.     while (cp > string && isword(*(cp - 1)))
  271.         cp--;
  272.     return cp;
  273. }
  274.  
  275.  
  276.  
  277. char *
  278. RunEdit(c, begin, cp, def, HowToRead)
  279. register int    c;
  280. register char    *begin,
  281.         *cp;
  282. char    *def;
  283. int    (*HowToRead)();
  284. {
  285.     char    *tcp;
  286.  
  287.     switch (c) {
  288.     case CTL(@):
  289.         break;
  290.  
  291.     case CTL(A):
  292.         cp = begin;
  293.         break;
  294.  
  295.     case CTL(B):
  296.         if (cp > begin)
  297.             --cp;
  298.         break;
  299.  
  300.     case CTL(D):
  301.         if (!*cp)
  302.             break;
  303.         cp++;
  304.         goto delchar;
  305.  
  306.     case CTL(E):
  307.         while (*cp)
  308.             cp++;
  309.         break;
  310.  
  311.     case CTL(F):
  312.         if (*cp)
  313.             cp++;
  314.         break;
  315.  
  316.     case CTL(G):
  317.         return (char *) -1;
  318.  
  319.     case CTL(K):
  320.         *cp = '\0';
  321.         break;
  322.  
  323.     case CTL(N):
  324.     case CTL(P):
  325.         ArgIns(begin, c == CTL(N));
  326.         cp = begin + strlen(begin);
  327.         break;
  328.  
  329.     case '\177':
  330.     case CTL(H):
  331. delchar:
  332.         if (cp == begin)
  333.             break;
  334.         strcpy(cp - 1, cp);
  335.         cp--;
  336.         break;
  337.  
  338.     case META(\177):    /* Delete previous word */
  339.     case CTL(W):
  340.         {
  341.         char    *tcp = backup(begin, cp);
  342.  
  343.         strcpy(tcp, cp);
  344.         cp = tcp;
  345.         }
  346.         break;
  347.  
  348.     case META(D):
  349.     case META(d):
  350.         strcpy(cp, jumpup(cp));
  351.         break;        /* Pretty neat huh */
  352.  
  353.     case META(B):
  354.     case META(b):
  355.         cp = backup(begin, cp);
  356.         break;
  357.  
  358.     case META(F):
  359.     case META(f):
  360.         cp = jumpup(cp);
  361.         break;
  362.  
  363.     case CTL(R):
  364.         if (!def || !*def) {
  365.             rbell();
  366.             break;
  367.         }
  368.         tcp = def;
  369.         while (c = *tcp++) {
  370.             insert(c, begin, (int) (cp - begin), 1, LBSIZE);
  371.             cp++;
  372.         }
  373.         break;
  374.  
  375.     case CTL(^):
  376.     case CTL(Q):
  377.         c = (*HowToRead)();
  378.         /* Fall into... */
  379.  
  380.     default:
  381.         if (c & 0200)
  382.             rbell();
  383.         else {
  384.             insert(c, begin, (int) (cp - begin), 1, ASKSIZE);
  385.             cp++;
  386.         }
  387.     }
  388.     return cp;
  389. }
  390.  
  391. NoMacGetc()
  392. {
  393.     int    c;
  394.  
  395.     redisplay();
  396.     if ((c = getchar()) == EOF)
  397.         finish(SIGHUP);
  398.     return c & 0177;
  399. }
  400.  
  401.  
  402.  
  403. /* VARARGS2 */
  404.  
  405. char *
  406. ask(def, fmt, args)
  407. char    *def,
  408.     *fmt;
  409. {
  410.     static char    string[ASKSIZE];
  411.     static char    *cp,
  412.         *begin;    /* Beginning of real text */
  413.     int    c;
  414.     extern int    (*Gtchar)();
  415.     int (*HowToRead)();
  416.  
  417. #ifdef UNIX
  418.     HowToRead = Interactive ? NoMacGetc : Gtchar;
  419. #else
  420.     if(Interactive)
  421.         HowToRead = NoMacGetc;
  422.     else HowToRead = Gtchar;
  423. #endif
  424.     
  425.     format(string, fmt, &args);
  426.     message(string);
  427.     Asking = strlen(string);    /* Entirely for redisplay */
  428.     begin = string + Asking;
  429.     cp = begin;
  430.     *cp = '\0';
  431.  
  432.     while ((c = (*HowToRead)()) != '\r' && c != '\n') {
  433.         NumArg = 1;    /* If not otherwise specified */
  434.         if (c == '\033')    /* Maybe a number */
  435.             c = GetArg(HowToRead);
  436.         else if (c == CTL(U))
  437.             c = GetFour(HowToRead);
  438.         if (c == '\033')    /* Again */
  439.             c = (*HowToRead)() | 0200;
  440.         while (NumArg-- > 0)
  441.             if ((int)(cp = RunEdit(c, begin, cp, def, HowToRead)) == -1)
  442.                 complain("Aborted");
  443.  
  444.         /* Show the change */
  445.         message(string);
  446.         Asking = cp - string;
  447.     }
  448.     Asking = 0;
  449.     if (cp == begin && *cp == '\0')    /* Nothing was typed */
  450.         if (def == 0)
  451.             complain("No default");
  452.         else
  453.             return def;
  454.     return begin;
  455. }
  456.  
  457. YankPop()
  458. {
  459.     LINE    *line,
  460.         *last;
  461.     MARK    *mp = CurMark();
  462.     BUFLOC    *dot;
  463.  
  464.     if (last_cmd != YANKCMD)
  465.         complain("Yank something first!");
  466.  
  467.     lfreelist(reg_delete(mp->m_line, mp->m_char, curline, curchar));
  468.  
  469.     /* Now must find a recently killed region. */
  470.  
  471.     killptr--;
  472.     for (;;) {
  473.         if (killptr < 0)
  474.             killptr = NUMKILLS - 1;
  475.         if (killbuf[killptr])
  476.             break;
  477.         killptr--;
  478.     }
  479.  
  480.     this_cmd = YANKCMD;
  481.  
  482.     line = killbuf[killptr];
  483.     last = lastline(line);
  484.     dot = DoYank(line, 0, last, length(last), curline, curchar, curbuf);
  485.     MarkSet(CurMark(), curline, curchar);
  486.     SetDot(dot);
  487. }
  488.  
  489. WtModBuf()
  490. {
  491.     int    askp = exp_p;
  492.     BUFFER    *oldb = curbuf,    
  493.         *bp;        
  494.     char    *yorn,
  495.         name[100];
  496.  
  497.     for (bp = world; bp; bp = bp->b_next) {
  498.         if (bp->b_zero == 0 || !IsModified(bp) ||
  499.                     bp->b_type == SCRATCHBUF)
  500.             continue;
  501.         SetBuf(bp);    /* Make this current buffer */
  502.         if (Crashing) {
  503.             strcpy(name, curbuf->b_name);
  504.             insert('_', name, 0, 1, 100);
  505.         } else {
  506.             if (curbuf->b_fname == 0)
  507.                 setfname(curbuf, ask((char *) 0, "No file.  File to use: "));
  508.             strcpy(name, curbuf->b_fname);
  509.         }
  510.         if (askp) {
  511.             yorn = ask((char *) 0, "Write %s? ", curbuf->b_fname);
  512.             if (*yorn != 'Y' && *yorn != 'y')
  513.                 continue;
  514.         }
  515.         file_write(name, 0);
  516.         SetUnmodified(curbuf);
  517.     }
  518.     SetBuf(oldb);
  519. }
  520.  
  521. NotModified()
  522. {
  523.     SetUnmodified(curbuf);
  524. }
  525.  
  526. ArgIns(at, next)
  527. char    *at;
  528. {
  529.     int    inc = next ? 1 : -1;
  530.  
  531.     if (*(argvp + inc) == 0)
  532.         inc = 0;
  533.     argvp += inc;
  534.     strcpy(at, *argvp);
  535. }
  536.  
  537. blnkp(buf)
  538. register char    *buf;
  539. {
  540.     register char    c;
  541.  
  542.     while ((c = *buf++) && (c == ' ' || c == '\t'))
  543.         ;
  544.     return c == 0;    /* It's zero if we got to the end of the line */
  545. }
  546.  
  547. DelBlnkLines()
  548. {
  549.     exp = 1;
  550.     if (!blnkp(linebuf) && !eolp())
  551.         return;
  552.     while (blnkp(linebuf) && curline->l_prev)
  553.         SetLine(curline->l_prev);
  554.  
  555.     Eol();
  556.     DelWtSpace();
  557.     NextLine();
  558.     while (blnkp(linebuf) && !eobp()) {
  559.         DelWtSpace();
  560.         DelNChar();
  561.     }
  562.     DelWtSpace();
  563. }
  564.  
  565.  
  566. Recurse()
  567. {
  568.     RecDepth++;
  569.     DoKeys(0);
  570.     RecDepth--;
  571. }
  572.  
  573. /* end */
  574.